package tool

import (
	"strings"
	"time"
	"unicode"
)

//time() 获取当前时间戳 单位秒
func Time() int64 {
	return time.Now().Unix()
}

/*
	1、strtotime() 日期字符串转时间戳
	2、Strtotime("02/01/2006 15:04:05", "02/01/2016 15:04:05") == 1451747045
*/
func Strtotime(format, strtime string) (int64, error) {
	t, err := time.Parse(format, strtime)
	if err != nil {
		return 0, err
	}
	return t.Unix(), nil
}

//date()
//Date("02/01/2006 15:04:05 PM", 1524799394)
func Date(format string, timestamp int64) string {
	return time.Unix(timestamp, 0).Format(format)
}

//sleep() 单位秒
func Sleep(t int64) {
	time.Sleep(time.Duration(t) * time.Second)
}

//sleep() 单位毫毛  时间单位 纳秒 = 10^3微妙 = 10^6毫秒 = 10^9 秒
func USleep(t int64) {
	time.Sleep(time.Duration(t) * time.Millisecond)
}

// strpos() 函数查找字符串在另一字符串中第一次出现的位置 大小写敏感 offset 可为负数
func Strpos(haystack, needle string, offset int) int {
	length := len(haystack)
	if length == 0 || offset > length || -offset > length {
		return -1
	}
	if offset < 0 {
		offset += length
	}
	pos := strings.Index(haystack[offset:], needle)
	if pos == -1 {
		return -1
	}
	return pos + offset
}

// strpos() 函数查找字符串在另一字符串中第一次出现的位置 大小写不敏感 offset 可为负数
func Stripos(haystack, needle string, offset int) int {
	length := len(haystack)
	if length == 0 || offset > length || -offset > length {
		return -1
	}
	if offset < 0 {
		offset += length
	}
	haystack = haystack[offset:]
	pos := strings.Index(strings.ToLower(haystack), strings.ToLower(needle))
	if pos == -1 {
		return -1
	}
	return pos + offset
}

//strrpos() 函数查找字符串在另一字符串中最后一次出现的位置 大小写敏感 offset 可为负数
func Strrpos(haystack, needle string, offset int) int {
	length := len(haystack)
	if length == 0 || offset > length || -offset > length {
		return -1
	}
	if offset < 0 {
		offset += length
	}
	haystack = haystack[offset:]
	pos := strings.LastIndex(haystack, needle)
	if pos == -1 {
		return -1
	}
	return offset + pos
}

//strripos() 函数查找字符串在另一字符串中最后一次出现的位置 大小写不敏感 offset 可为负数
func Strripos(haystack, needle string, offset int) int {
	length := len(haystack)
	if length == 0 || offset > length || -offset > length {
		return -1
	}
	if offset < 0 {
		offset += length
	}
	haystack = haystack[offset:]
	pos := strings.LastIndex(strings.ToLower(haystack), strings.ToLower(needle))
	if pos == -1 {
		return -1
	}
	return offset + pos
}

//ucfirst() 把字符串中的首字符转换为大写
func Ucfirst(str string) string {
	for _, v := range str {
		u := string(unicode.ToUpper(v))
		return u + str[len(u):]
	}
	return ""
}

//lcfirst() 把字符串中的首字符转换为小写
func Lcfirst(str string) string {
	for _, v := range str {
		u := string(unicode.ToLower(v))
		return u + str[len(u):]
	}
	return ""
}

//ucwords() 把字符串中每个单词的首字符转换为大写
func Ucwords(str string) string {
	return strings.Title(str)
}

//substr 字符串截取，只支持正向截取，length -1表示一直到最后
func Substr(str string, start uint, length int) string {
	strlen := len(str)
	if strlen == 0 || start < 0 || length < -1 {
		return ""
	}
	switch length {
	case -1:
		return str[start:]
	case 0:
		return ""
	default:
	}
	end := int(start) + length
	if end > strlen {
		return str[start:strlen]
	}
	return str[start:end]
}

//strrev() 字符串烦转
func Strrev(str string) string {
	runes := []rune(str)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}
